Compile-time register requirements analysis for μTC using the GCC framework

Register allocation is one of the biggest challenges in compiler design. The allocation scheme implemented by the compiler impacts directly on the processor’s performance. The SVP model, implemented in processors supporting micro-threads, provides an alternative solution for programming the next generation of many-core chip multiprocessors. This model is captured in a new language called μTC (a system rather than an end-user language) and this paper investigates the register allocation problem when compiling μTC to microthreaded assembler. The compiler developed is based on GCC but the register allocation problem is made significantly more complex because of the requirements to manage many overlapping contexts for the lightweight threads and to keep these entirely in registers, wherever possible. This has required a very different approach to the existing GCC strategy. SVP captures both function application and loops by creating homogeneous families of blocking threads, where a thread may read and block on another’s context of synchronising variables. Because of this, the context is partitioned into four different classes: locals, globals, shareds and dependents, the latter two providing thread-to-thread communication. Before register allocation can be done, the compiler must identify variables in each class and also provide a mapping between the locals in the creating thread and the shareds and globals of the created threads (its arguments). This paper describes the problem and presents the analysis of μTC code used to predict how the variables in each class should be arranged in the thread’s context to meet the SVP model’s implementation requirements.